import random as rd
import math

def JeuxAvecStrategie1(etat, n):
    fin_partie = False

    if etat in attracteurs[0]:
        partie = [("position_initiale_gagnante_J0 / J"+str(etat[1])+" commence")]
    elif etat in attracteurs[1]:
        partie = [("position_initiale_gagnante_J1 / J"+str(etat[1])+" commence")]
    else:
        partie = [("position_initiale_nulle / J"+str(etat[1])+" commence")]

    etat_ = etat
    while fin_partie == False:
        etat, type = strategie1(etat_)
        partie.append((etat_, type))

        # Vérifie si c'est un état final
        fin_partie, joueur_gagnant = partie_finie(n,etat[0])
        etat_ = etat

    partie.append((etat_, "fin partie"))

    return partie, joueur_gagnant

def JeuxAvecStrategieMiniMax(etat, n):
    fin_partie = False

    if etat in attracteurs[0]:
        partie = [("position_initiale_gagnante_J0 / J"+str(etat[1])+" commence")]
    elif etat in attracteurs[1]:
        partie = [("position_initiale_gagnante_J1 / J"+str(etat[1])+" commence")]
    else:
        partie = [("position_initiale_nulle / J"+str(etat[1])+" commence")]

    etat_ = etat
    while fin_partie == False:
        etat, type, cote = strategieMinMax(etat_)
        partie.append((etat_, type, cote))

        # Vérifie si c'est un état final
        fin_partie, joueur_gagnant = partie_finie(n,etat[0])
        etat_ = etat

    partie.append((etat_, "fin partie"))

    return partie, joueur_gagnant

def EvaluerStrategieMiniMax_heur(p,n):
    # ordre des cases : [minimax = -1, minimax = 0, minimax = 1]
    # répartition des coups choisis par l’heuristique
    # entre perdants / nuls / gagnants ;
    nbre_choix = [0, 0, 0]

    # répartition de tous les coups possibles
    # entre perdants / nuls / gagnants.
    nbre_tout  = [0, 0, 0]

    # on parcourt les états atteints après 2 coups depuis l'état initial
    for etat1 in suivants(etat_initial):
        for etat2 in suivants(etat1):
            # coups choisis par la stratégie heuristique à profondeur p
            choix = strategieMiniMax_heur(etat2, p, n)

            # comptage des vraies valeurs minimax des coups choisis
            # par l'heuristique
            for s in choix:
                nbre_choix[minimax(s) + 1] += 1

            # comptage des vraies valeurs minimax de tous les coups possibles
            for s in suivants(etat2):
                nbre_tout[minimax(s) + 1] += 1

    print("Ordre : [J1 gagne, nul, J0 gagne] = [-1, 0, 1]")
    print("Coups choisis par la stratégie heuristique :", nbre_choix)
    print("Tous les coups possibles                   :", nbre_tout)


# Chaînes gagnantes pour tests
###################################
# Cette chaîne simule une victoire de 'O' sur la ligne du milieu (cases 3, 4 et 5).
c_victoire_J0_ligne = 'X.XOOO..X'

# Ici, 'X' a réussi à aligner ses symboles sur la première colonne (cases 0, 3 et 6).
c_victoire_J1_colonne = 'XO.XO.X.O'

# Une victoire de 'O' sur la diagonale principale (cases 0, 4 et 8).
c_victoire_J0_diag = 'OX.XO..XO'

# Match Nul (Grille pleine, aucun gagnant)
c_match_nul = 'OXOOXXXOO'

# Partie en cours (Grille non pleine, aucun gagnant)
c_en_cours = 'OX..O....'

##########################################
##########################################

joueurs = {'O' : 0, 'X' : 1}
symboles = {0 : 'O', 1 : 'X'}
etat_initial = ('.'*9, 0)       # grille vide et J0 commence